American Depositary Reciepts (ADRs) are financial instruments that allow US investors to purchase stocks in foreign companies. Argentina has a number of companies listed in US exchanges through ADRs.
In this notebook, we will explore the performance of these ADRs with a focus on the recent months, where political uncertainty sent markets into turmoil: the country’s Merval stock index fell 48% in dollar terms in a single day, the second-largest one-day drop in any of the 94 markets tracked by Bloomberg since 1950[1], causing a 20% devaluation of the Argentine peso and a sharp drop in bond prices.
We will be looking at the end-of-day data of the Argentine ADRs, and their corresponding put and call options.
Data munging¶
data_dir = 'data/'
tickers = [
'BMA', 'BFR', 'CEPU', 'CRESY', 'EDN', 'GGAL', 'SUPV', 'IRS',
'IRCP', 'LOMA', 'NTL', 'MELI', 'PAM', 'PZE', 'TEO', 'TS', 'TX',
'TGS', 'YPF'
]
dfs = [pd.read_csv(os.path.join(data_dir, ticker.lower() + '.csv')) for ticker in tickers]
adrs_df = pd.concat(dfs, axis=0, ignore_index=False)
adrs_df.to_csv(os.path.join(data_dir, 'adrs.csv'), index=False)
Exploration¶
We begin our exploration of the end-of-day (EOD) data for Argentina's ADRs.
adrs_df = pd.read_csv(os.path.join(data_dir, 'adrs.csv'), index_col='date', parse_dates=['date'])
adrs_df.index = pd.DatetimeIndex(adrs_df.index.date, name='date')
adrs_df.head()
The data is indexed by date, with the symbol column holding the ticker name, and columns for the open and close prices (the price of the symbol at the start/end of the market day) and the high and low prices seen for the symbol at that date.
We'll begin plotting the adjusted close prices for each symbol (price adjusted for dividends payed and stock splits). The reset of the columns can be safely ingored for our purposes.
Let's zoom in on the 2019 adjusted close prices.
adrs_df.groupby('symbol')['adjClose'].describe()
Daily returns¶
Next we'll calculate the daily returns.
$$R_n \equiv \frac{S_n - S_{n-1}}{S_{n-1}} \%$$adrs_df['return'] = adrs_df.groupby('symbol')['adjClose'].pct_change() * 100
adrs_df.head()
adrs_df.groupby('symbol')['return'].describe()
Let's plot a histogram of the daily returns for each symbol.
We see most returns cluster around 0, with a few outliers. We can visualize them using a boxenplot.
We can filter the days with 30% or larger movement in prices (either up or down).
Now if we remove outliers, say discard days where return was higher than 10% or lower than -10%:
In finance, it is common to look at the log returns of an asset. Stock prices are assumed to follow a log-normal distribution, hence we should expect log returns to be distributed normally.
$$ln(S_T)\sim N\big[ln(S_0)+(\mu-\frac{\sigma^2}{2})T,\;\sigma^2T\big] \\ ln(\frac{S_T}{S_0})\sim N\big[(\mu-\frac{\sigma^2}{2})T, \;\sigma^2T\big]$$Where $S_T$ is the price of the underlying at time $T$.
For a more detailed discussion on the assumptions of the Black-Scholes-Merton model, see chapter 15 of Options, Futures and Other Derivatives (9th Ed) by John Hull.
You can read more on the distribution of prices and returns here.
adrs_df['log_return'] = np.log(adrs_df['return'] / 100 + 1.)
Now we can calculate the volatility) $\sigma$ for each symbol, defined as the standard deviation of log returns.
As a comparison, we'll add the daily volatility (from 2000 to 2018) for the S&P 500 index, a stock market index that measures the stock performance of the 500 largest publicly traded companies in the United States.
spx_df = pd.read_csv(os.path.join(data_dir, 'spx_2000-2018.csv'),
index_col='date',
parse_dates=['date'])
spx_df['log_return'] = np.log(spx_df['price'] / spx_df['price'].shift(1))
adr_volatility = adrs_df.groupby('symbol')['log_return'].std()
adr_volatility['SPX'] = spx_df['log_return'].std()
sns.barplot(x=adr_volatility.index, y=adr_volatility.values).set_title(
'Daily volatility $\sigma_{daily}$ for each symbol (std of log returns)',
size=16);
Let's plot the mean yearly returns for each symbol. Again, we'll add the mean daily return of \$SPX as a benchmark.
A closer look at outliers¶
Let's plot the returns that are $3\sigma$ away from the mean. If log returns were truly distributed normally, then we should expect $99.7\%$ of them to lie in the interval $(\mu_R - 3\sigma, \mu_R + 3\sigma)$.
def outlier_filter(symbol_df):
symbol = symbol_df['symbol'].iloc[0]
return symbol_df.loc[(symbol_df['log_return'] -
symbol_df['log_return'].mean()).abs() >= 3 *
adr_volatility[symbol]]
outliers = adrs_df.groupby('symbol').apply(outlier_filter).reset_index(
level=0, drop=True)
sns.scatterplot(x=outliers.index, y='log_return', hue='symbol',
data=outliers).set_title('$3\sigma$ outlier daily returns',
size=16);
We see a large number of outlier return days. To put that in perspective, let's calculate the proportion of outlier returns for each symbol in the data, that is the number of days where $3\sigma$ returns where observed over the total number of observations.
Finally, we'll look at the cumulative log returns over time.
pivoted = adrs_df.pivot(columns='symbol', values='log_return')
pivoted.cumsum().apply(np.exp).plot(title='Cumulative log returns');
ADR options and the volatility smile¶
Now we'll examine the options end-of-day data for the ADRs. Options are derivative contracts based on an underlying asset such as stocks. They offer the buyer the opportunity to buy or sell the underlying asset at a given price (strike price). You can find more information on options in this notebook.
The options data is also indexed by date. These are the most important columns:
underlying: The ticker of the underlying asset.underlying_last: The last quoted price of the underlying asset.optionroot: The name of the contract.type: Contract type (put or call)strike: The price at which owner can execute (buy/sell underlying).expiration: Date of expiration of the option.bid: The price at which investor can sell this contract.ask: The price at which investor can buy this contract.openinterest: The total number of contract outstanding.impliedvol: Volatility of the underlying as implied by the option price (according to BSM model)
Let's plot the volatility smile for each symbol at 2019-08-09.
The volatility smile plots the implied volatility (IV, a measure of the volatility of an underlying security as implied by the option prices) at the different strike levels.
We'll plot the IV for puts and calls for each symbol. The dashed line represents the spot price.
Now let's try the same plot for the following Monday (2019-08-12). That day, the MERVAL (an index that tracks the biggest companies listed in the Buenos Aires Stock Exchange) crashed and lost close to 50% of its USD value.
Option price evolution¶
Next, we'll analyse how option prices changed during the month of August, 2019. Let's find the 10 most actively traded options (those with the highest open interest) for each symbol at the start of the month.
august_options = adr_options.loc['2019-08']
def filter_active(symbol_df, option_type='call'):
return symbol_df.loc[symbol_df['type'] == option_type].nlargest(
n=10, columns='openinterest')
month_start_date = august_options.index.min()
first_trading_day = august_options.loc[month_start_date]
most_active_calls = first_trading_day.groupby('underlying').apply(
filter_active).reset_index(level=0, drop=True)
most_active_puts = first_trading_day.groupby('underlying').apply(
lambda df: filter_active(df, 'put')).reset_index(level=0, drop=True)
call_contracts = most_active_calls['optionroot']
put_contracts = most_active_puts['optionroot']
august_active_calls = august_options.loc[august_options['optionroot'].isin(call_contracts)]
august_active_puts = august_options.loc[august_options['optionroot'].isin(put_contracts)]
august_active_calls['day'] = august_active_calls.index.strftime('%d')
august_active_puts['day'] = august_active_puts.index.strftime('%d')
August 2019¶
We'll plot the evolution of the ask price for the actively traded calls through August 2019.
June 2019¶
As a comparison, let's try plotting the option prices for June 2019.
june_options = adr_options.loc['2019-06']
October 2015¶
october_2015_options = pd.read_csv(os.path.join(data_dir, 'adr_options_October_2015.csv'),
index_col='quotedate',
parse_dates=['quotedate', 'expiration'])
November 2015¶
november_2015_options = pd.read_csv(os.path.join(data_dir, 'adr_options_november_2015.csv'),
index_col='quotedate',
parse_dates=['quotedate', 'expiration'])
December 2015¶
december_2015_options = pd.read_csv(os.path.join(data_dir, 'adr_options_December_2015.csv'),
index_col='quotedate',
parse_dates=['quotedate', 'expiration'])
January 2008¶
We'll examine the options data for January 2008, the beginning of the mortgage crisis. We only have data for 3 companies: \$MELI, \\$TS and \$TX
january_2008_options = pd.read_csv(os.path.join(data_dir, 'adr_options_january_2008.csv'),
index_col='quotedate',
parse_dates=['quotedate', 'expiration'])
Final notes¶
Countries such as Argentina exhibit high political beta: stocks show extreme sensitivity to political events. The MERVAL index nearly quadrupled its value in Pesos since December 2015, only to drop by %40 in a single day in August 2019.
Investors tend to exacerbate bull runs, discounting future growth in the current stock prices. At the prospect of regulatory changes and political turnover, they panic sell and seek less risky assets. There remains to be seen whether savvy traders can exploit both the overconfident bulls and the panicking bears, buying volatility from the former to sell it at a profit to the latter.